#ifndef __THREAD_HPP__
#define __THREAD_HPP__
#include <iostream>
#include <pthread.h> //原生线程库
#include <functional>
#include <string>
#include <unistd.h>

namespace ThreadModule
{
    // using 就相当于typedef  实现模板的function包装器，可以包装任意返回值为void参数为(T& data)的函数，引用至同一个全局变量并能修改
    // template <typename T>  去掉，线程池这里用全新的方式
    using func_t = std::function<void(const std::string &)>;

    // 声明称模板，可以任意类型数据让线程执行嘛
    class Thread
    {
    public:
        void Excute()
        {
            _func(_threadname);
        }

    public:
        std::string name()
        {
            return _threadname;
        }
        Thread(func_t func, const std::string name = "non-name")
            : _func(func), _threadname(name), _stop(true) // 没有启动
        {
        }
        ~Thread()
        {
        }
        // 线程执行函数
        static void *threadrun(void *args) // 但是这样不行，类成员函数第一个参数是this，所以第一个参数被占了，传不到，所以静态
        {
            Thread *self = static_cast<Thread *>(args); // 强转回来
            self->Excute();                             // 调用Excute
            return nullptr;                             // 返回值暂时给nullptr，不关心
        }
        // 启动线程, 启动成功返回true，否则返回false
        bool Start()
        {
            int n = pthread_create(&_tid, nullptr, threadrun, this); // 静态可以传入了，但是没有this指针，所以参数就传this
            if (!n)
            {
                // 启动成功
                _stop = false;
                return true;
            }
            else
            {
                return false; // 启动失败
            }
        }
        // 线程分离
        void Detach()
        {
            if (!_stop)
                pthread_detach(_tid);
        }
        // 回收线程
        void Join()
        {
            if (!_stop)
                pthread_join(_tid, nullptr);
        }
        void Stop()
        {
            _stop = true;
        }

    private:
        pthread_t _tid;
        std::string _threadname;
        func_t _func;
        bool _stop;
    };
}

#endif
